home *** CD-ROM | disk | FTP | other *** search
/ Windows Expert / Windows Expert.iso / windownt / mbison.zip / BISON.HAI < prev    next >
Text File  |  1993-02-08  |  6KB  |  335 lines
  1.  
  2. extern int timeclock;
  3.  
  4.  
  5. int yyerror;        /*  Yyerror and yycost are set by guards.    */
  6. int yycost;        /*  If yyerror is set to a nonzero value by a    */
  7.             /*  guard, the reduction with which the guard    */
  8.             /*  is associated is not performed, and the    */
  9.             /*  error recovery mechanism is invoked.    */
  10.             /*  Yycost indicates the cost of performing    */
  11.             /*  the reduction given the attributes of the    */
  12.             /*  symbols.                    */
  13.  
  14.  
  15. /*  YYMAXDEPTH indicates the size of the parser's state and value    */
  16. /*  stacks.                                */
  17.  
  18. #ifndef    YYMAXDEPTH
  19. #define    YYMAXDEPTH    500
  20. #endif
  21.  
  22. /*  YYMAXRULES must be at least as large as the number of rules that    */
  23. /*  could be placed in the rule queue.  That number could be determined    */
  24. /*  from the grammar and the size of the stack, but, as yet, it is not.    */
  25.  
  26. #ifndef    YYMAXRULES
  27. #define    YYMAXRULES    100
  28. #endif
  29.  
  30. #ifndef    YYMAXBACKUP
  31. #define YYMAXBACKUP    100
  32. #endif
  33.  
  34.  
  35. short    yyss[YYMAXDEPTH];    /*  the state stack            */
  36. YYSTYPE    yyvs[YYMAXDEPTH];    /*  the semantic value stack        */
  37. YYLTYPE yyls[YYMAXDEPTH];    /*  the location stack            */
  38. short    yyrq[YYMAXRULES];    /*  the rule queue            */
  39. int    yychar;            /*  the lookahead symbol        */
  40.  
  41. YYSTYPE    yylval;            /*  the semantic value of the        */
  42.                 /*  lookahead symbol            */
  43.  
  44. YYSTYPE yytval;            /*  the semantic value for the state    */
  45.                 /*  at the top of the state stack.    */
  46.  
  47. YYSTYPE yyval;            /*  the variable used to return        */
  48.                 /*  semantic values from the action    */
  49.                 /*  routines                */
  50.  
  51. YYLTYPE yylloc;        /*  location data for the lookahead    */
  52.                 /*  symbol                */
  53.  
  54. YYLTYPE yytloc;        /*  location data for the state at the    */
  55.                 /*  top of the state stack        */
  56.  
  57.  
  58. int    yynunlexed;
  59. short    yyunchar[YYMAXBACKUP];
  60. YYSTYPE    yyunval[YYMAXBACKUP];
  61. YYLTYPE yyunloc[YYMAXBACKUP];
  62.  
  63. short *yygssp;            /*  a pointer to the top of the state    */
  64.                 /*  stack; only set during error    */
  65.                 /*  recovery.                */
  66.  
  67. YYSTYPE *yygvsp;        /*  a pointer to the top of the value    */
  68.                 /*  stack; only set during error    */
  69.                 /*  recovery.                */
  70.  
  71. YYLTYPE *yyglsp;        /*  a pointer to the top of the        */
  72.                 /*  location stack; only set during    */
  73.                 /*  error recovery.            */
  74.  
  75.  
  76. /*  Yyget is an interface between the parser and the lexical analyzer.    */
  77. /*  It is costly to provide such an interface, but it avoids requiring    */
  78. /*  the lexical analyzer to be able to back up the scan.        */
  79.  
  80. yyget()
  81. {
  82.   if (yynunlexed > 0)
  83.     {
  84.       yynunlexed--;
  85.       yychar = yyunchar[yynunlexed];
  86.       yylval = yyunval[yynunlexed];
  87.       yylloc = yyunloc[yynunlexed];
  88.     }
  89.   else if (yychar <= 0)
  90.     yychar = 0;
  91.   else
  92.     {
  93.       yychar = yylex();
  94.       if (yychar < 0)
  95.     yychar = 0;
  96.       else yychar = YYTRANSLATE(yychar);
  97.     }
  98. }
  99.  
  100.  
  101.  
  102. yyunlex(chr, val, loc)
  103. int chr;
  104. YYSTYPE val;
  105. YYLTYPE loc;
  106. {
  107.   yyunchar[yynunlexed] = chr;
  108.   yyunval[yynunlexed] = val;
  109.   yyunloc[yynunlexed] = loc;
  110.   yynunlexed++;
  111. }
  112.  
  113.  
  114.  
  115. yyrestore(first, last)
  116. register short *first;
  117. register short *last;
  118. {
  119.   register short *ssp;
  120.   register short *rp;
  121.   register int symbol;
  122.   register int state;
  123.   register int tvalsaved;
  124.  
  125.   ssp = yygssp;
  126.   yyunlex(yychar, yylval, yylloc);
  127.  
  128.   tvalsaved = 0;
  129.   while (first != last)
  130.     {
  131.       symbol = yystos[*ssp];
  132.       if (symbol < YYNTBASE)
  133.     {
  134.       yyunlex(symbol, yytval, yytloc);
  135.       tvalsaved = 1;
  136.       ssp--;
  137.     }
  138.  
  139.       ssp--;
  140.  
  141.       if (first == yyrq)
  142.     first = yyrq + YYMAXRULES;
  143.  
  144.       first--;
  145.  
  146.       for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
  147.     {
  148.       if (symbol < YYNTBASE)
  149.         state = yytable[yypact[*ssp] + symbol];
  150.       else
  151.         {
  152.           state = yypgoto[symbol - YYNTBASE] + *ssp;
  153.  
  154.           if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
  155.         state = yytable[state];
  156.           else
  157.         state = yydefgoto[symbol - YYNTBASE];
  158.         }
  159.  
  160.       *++ssp = state;
  161.     }
  162.     }
  163.  
  164.   if ( ! tvalsaved && ssp > yyss)
  165.     {
  166.       yyunlex(yystos[*ssp], yytval, yytloc);
  167.       ssp--;
  168.     }
  169.  
  170.   yygssp = ssp;
  171. }
  172.  
  173.  
  174.  
  175. int
  176. yyparse()
  177. {
  178.   register int yystate;
  179.   register int yyn;
  180.   register short *yyssp;
  181.   register short *yyrq0;
  182.   register short *yyptr;
  183.   register YYSTYPE *yyvsp;
  184.  
  185.   int yylen;
  186.   YYLTYPE *yylsp;
  187.   short *yyrq1;
  188.   short *yyrq2;
  189.  
  190.   yystate = 0;
  191.   yyssp = yyss - 1;
  192.   yyvsp = yyvs - 1;
  193.   yylsp = yyls - 1;
  194.   yyrq0 = yyrq;
  195.   yyrq1 = yyrq0;
  196.   yyrq2 = yyrq0;
  197.  
  198.   yychar = yylex();
  199.   if (yychar < 0)
  200.     yychar = 0;
  201.   else yychar = YYTRANSLATE(yychar);
  202.  
  203. yynewstate:
  204.  
  205.   if (yyssp >= yyss + YYMAXDEPTH - 1)
  206.     {
  207.       yyabort("Parser Stack Overflow");
  208.       YYABORT;
  209.     }
  210.  
  211.   *++yyssp = yystate;
  212.  
  213. yyresume:
  214.  
  215.   yyn = yypact[yystate];
  216.   if (yyn == YYFLAG)
  217.     goto yydefault;
  218.  
  219.   yyn += yychar;
  220.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
  221.     goto yydefault;
  222.  
  223.   yyn = yytable[yyn];
  224.   if (yyn < 0)
  225.     {
  226.       yyn = -yyn;
  227.       goto yyreduce;
  228.     }
  229.   else if (yyn == 0)
  230.     goto yyerrlab;
  231.  
  232.   yystate = yyn;
  233.  
  234.   yyptr = yyrq2;
  235.   while (yyptr != yyrq1)
  236.     {
  237.       yyn = *yyptr++;
  238.       yylen = yyr2[yyn];
  239.       yyvsp -= yylen;
  240.       yylsp -= yylen;
  241.  
  242.       yyguard(yyn, yyvsp, yylsp);
  243.       if (yyerror)
  244.     goto yysemerr;
  245.  
  246.       yyaction(yyn, yyvsp, yylsp);
  247.       *++yyvsp = yyval;
  248.  
  249.       yylsp++;
  250.       if (yylen == 0)
  251.     {
  252.       yylsp->timestamp = timeclock;
  253.       yylsp->first_line = yytloc.first_line;
  254.       yylsp->first_column = yytloc.first_column;
  255.       yylsp->last_line = (yylsp-1)->last_line;
  256.       yylsp->last_column = (yylsp-1)->last_column;
  257.       yylsp->text = 0;
  258.     }
  259.       else
  260.     {
  261.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  262.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  263.     }
  264.       
  265.       if (yyptr == yyrq + YYMAXRULES)
  266.         yyptr = yyrq;
  267.     }
  268.  
  269.   if (yystate == YYFINAL)
  270.     YYACCEPT;
  271.  
  272.   yyrq2 = yyptr;
  273.   yyrq1 = yyrq0;
  274.  
  275.   *++yyvsp = yytval;
  276.   *++yylsp = yytloc;
  277.   yytval = yylval;
  278.   yytloc = yylloc;
  279.   yyget();
  280.  
  281.   goto yynewstate;
  282.  
  283. yydefault:
  284.  
  285.   yyn = yydefact[yystate];
  286.   if (yyn == 0)
  287.     goto yyerrlab;
  288.  
  289. yyreduce:
  290.  
  291.   *yyrq0++ = yyn;
  292.  
  293.   if (yyrq0 == yyrq + YYMAXRULES)
  294.     yyrq0 = yyrq;
  295.  
  296.   if (yyrq0 == yyrq2)
  297.     {
  298.       yyabort("Parser Rule Queue Overflow");
  299.       YYABORT;
  300.     }
  301.  
  302.   yyssp -= yyr2[yyn];
  303.   yyn = yyr1[yyn];
  304.  
  305.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  306.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  307.     yystate = yytable[yystate];
  308.   else
  309.     yystate = yydefgoto[yyn - YYNTBASE];
  310.  
  311.   goto yynewstate;
  312.  
  313. yysemerr:
  314.   *--yyptr = yyn;
  315.   yyrq2 = yyptr;
  316.   yyvsp += yyr2[yyn];
  317.  
  318. yyerrlab:
  319.  
  320.   yygssp = yyssp;
  321.   yygvsp = yyvsp;
  322.   yyglsp = yylsp;
  323.   yyrestore(yyrq0, yyrq2);
  324.   yyrecover();
  325.   yystate = *yygssp;
  326.   yyssp = yygssp;
  327.   yyvsp = yygvsp;
  328.   yyrq0 = yyrq;
  329.   yyrq1 = yyrq0;
  330.   yyrq2 = yyrq0;
  331.   goto yyresume;
  332. }
  333.  
  334. $
  335.